home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / misc / sci / ephem_src_4_28.lha / altmenus.c < prev    next >
C/C++ Source or Header  |  1992-05-11  |  11KB  |  410 lines
  1. /* routines for managing the alternative bottom half menus.
  2.  * planet-specific menus are in their own files.
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include <math.h>
  7. #include "astro.h"
  8. #include "circum.h"
  9. #include "screen.h"
  10.  
  11. static void alt1_body (int p, int force, Now *np);
  12. static void alt2_body (int p, int force, Now *np);
  13. static void alt3_body (int p, int force, Now *np);
  14.  
  15. static int altmenu = F_MNU1;    /* which alternate menu is up; one of F_MNUi */
  16. static int alt2_stdhzn;    /* whether to use STDHZN (aot ADPHZN) horizon algthm  */
  17. static int alt3_geoc;    /* whether to use geocentric (aot topocentric) vantage*/
  18.  
  19. /* table of screen rows given a body #define from astro/h or screen.h */
  20. static short bodyrow[NOBJ] = {
  21.     R_MERCURY, R_VENUS, R_MARS, R_JUPITER, R_SATURN,
  22.     R_URANUS, R_NEPTUNE, R_PLUTO, R_SUN, R_MOON, R_OBJX, R_OBJY
  23. };
  24. /* table of screen cols for third menu format, given body #define ... */
  25. static short bodycol[NOBJ] = {
  26.     C_MERCURY, C_VENUS, C_MARS, C_JUPITER, C_SATURN,
  27.     C_URANUS, C_NEPTUNE, C_PLUTO, C_SUN, C_MOON, C_OBJX, C_OBJY
  28. };
  29.  
  30. /* initialize altmenu; used by main from cracking the ephem startup file.
  31.  */
  32. altmenu_init (n)
  33. int n;
  34. {
  35.     altmenu = n;
  36. }
  37.  
  38. /* let op decide which alternate menu should be up,
  39.  * including any menu-specific setup they might require.
  40.  * return 0 if things changed to require updating the alt menu; else -1.
  41.  */
  42. altmenu_setup()
  43. {
  44.     static char *flds[5] = {
  45.         "Data", "(Rise/Set", "", "(Separations"
  46.     };
  47.     int newmenu = altmenu, newhzn = alt2_stdhzn, newgeoc = alt3_geoc;
  48.     int new;
  49.     int fn = altmenu == F_MNU3 ? 3 : altmenu == F_MNU2 ? 1 : 0;
  50.  
  51.     ask:
  52.     flds[2]= newhzn ? "Standard hzn)" : "Adaptive hzn)";
  53.     flds[4]= newgeoc? "Geocentric)" : "Topocentric)";
  54.  
  55.     switch (popup (flds, fn, 5)) {
  56.     case 0: newmenu = F_MNU1; break;
  57.     case 1: newmenu = F_MNU2; break;
  58.     case 2: newhzn ^= 1; fn = 2; goto ask;
  59.     case 3: newmenu = F_MNU3; break;
  60.     case 4: newgeoc ^= 1; fn = 4; goto ask;
  61.     default: return (-1);
  62.     }
  63.  
  64.     new = 0;
  65.     if (newmenu != altmenu) {
  66.         altmenu = newmenu;
  67.         new++;
  68.     }
  69.     if (newhzn != alt2_stdhzn) {
  70.         alt2_stdhzn = newhzn;
  71.         if (newmenu == F_MNU2)
  72.         new++;
  73.     }
  74.     if (newgeoc != alt3_geoc) {
  75.         alt3_geoc = newgeoc;
  76.         if (newmenu == F_MNU3)
  77.         new++;
  78.     }
  79.     return (new ? 0 : -1);
  80. }
  81.  
  82. /* erase the info for the given planet */
  83. alt_nobody (p)
  84. int p;
  85. {
  86.     f_eol (bodyrow[p], C_RA);
  87. }
  88.  
  89. alt_body (b, force, np)
  90. int b;        /* which body, ala astro.h and screen.h defines */
  91. int force;    /* if !0 then draw for sure, else just if changed since last */
  92. Now *np;
  93. {
  94.     switch (altmenu) {
  95.     case F_MNU1: alt1_body (b, force, np); break;
  96.     case F_MNU2: alt2_body (b, force, np); break;
  97.     case F_MNU3: alt3_body (b, force, np); break;
  98.     }
  99. }
  100.  
  101. /* draw the labels for the current alternate menu format */
  102. alt_labels ()
  103. {
  104.     switch (altmenu) {
  105.     case F_MNU1: alt1_labels (); break;
  106.     case F_MNU2: alt2_labels (); break;
  107.     case F_MNU3: alt3_labels (); break;
  108.     case F_MNUJ: altj_labels (); break;
  109.     }
  110. }
  111.  
  112. alt_erase ()
  113. {
  114.     int i;
  115.  
  116.     for (i = R_PLANTAB; i <= NR; i++)
  117.         f_eol (i, 1);
  118.     f_string (R_ALTM, C_ALTMV, "             ");
  119. }
  120.  
  121. alt_menumask()
  122. {
  123.     return (altmenu);
  124. }
  125.  
  126. /* handy function to return the next planet in the order in which they are
  127.  * displayed in the lower half of the screen.
  128.  * input is a given planet, return is the next planet.
  129.  * if input is not legal, then first planet is returned; when input is the
  130.  * last planet, then -1 is returned.
  131.  * typical usage is something like:
  132.  *   for (p = nxtbody(-1); p != -1; p = nxtbody(p))
  133.  */
  134. nxtbody(p)
  135. int p;
  136. {
  137.     static short nxtpl[NOBJ] = {
  138.         VENUS, MARS, JUPITER, SATURN, URANUS,
  139.         NEPTUNE, PLUTO, OBJX, MOON, MERCURY, OBJY, -1
  140.     };
  141.  
  142.     if (p < MERCURY || p >= NOBJ)
  143.         return (SUN);
  144.     else
  145.         return (nxtpl[p]);
  146. }
  147.  
  148. alt_plnames()
  149. {
  150.     f_string (R_PLANTAB,    C_OBJ,    "OCX");
  151.     f_string (R_SUN,    C_OBJ,    "Su");
  152.     f_string (R_MOON,    C_OBJ,    "Mo");
  153.     f_string (R_MERCURY,    C_OBJ,    "Me");
  154.     f_string (R_VENUS,    C_OBJ,    "Ve");
  155.     f_string (R_MARS,    C_OBJ,    "Ma");
  156.     f_string (R_JUPITER,    C_OBJ,    "Ju");
  157.     f_string (R_SATURN,    C_OBJ,    "Sa");
  158.     f_string (R_URANUS,    C_OBJ,    "Ur");
  159.     f_string (R_NEPTUNE,    C_OBJ,    "Ne");
  160.     f_string (R_PLUTO,    C_OBJ,    "Pl");
  161.     f_string (R_OBJX,    C_OBJ,    "X");
  162.     f_string (R_OBJY,    C_OBJ,    "Y");
  163. }
  164.  
  165. static
  166. alt1_labels()
  167. {
  168.     f_string (R_ALTM, C_ALTMV, "  Planet Data");
  169.  
  170.     alt_plnames();
  171.     f_string (R_PLANTAB,    C_RA+2,    "R.A.");
  172.     f_string (R_PLANTAB,    C_DEC+2,"Dec");
  173.     f_string (R_PLANTAB,    C_AZ+2,    "Az");
  174.     f_string (R_PLANTAB,    C_ALT+2,"Alt");
  175.     f_string (R_PLANTAB,    C_HLONG,"H Long");
  176.     f_string (R_PLANTAB,    C_HLAT,    "H Lat");
  177.     f_string (R_PLANTAB,    C_EDIST,"Ea Dst");
  178.     f_string (R_PLANTAB,    C_SDIST,"Sn Dst");
  179.     f_string (R_PLANTAB,    C_ELONG,"Elong");
  180.     f_string (R_PLANTAB,    C_SIZE,    "Size");
  181.     f_string (R_PLANTAB,    C_MAG,    "VMag");
  182.     f_string (R_PLANTAB,    C_PHASE,"Phs");
  183. }
  184.  
  185. static
  186. alt2_labels()
  187. {
  188.     f_string (R_ALTM, C_ALTMV, "Rise/Set Info");
  189.  
  190.     alt_plnames();
  191.     f_string (R_PLANTAB,    C_RISETM-2,    "Rise Time");
  192.     f_string (R_PLANTAB,    C_RISEAZ,    "Rise Az");
  193.     f_string (R_PLANTAB,    C_TRANSTM-2,    "Trans Time");
  194.     f_string (R_PLANTAB,    C_TRANSALT-1,    "Trans Alt");
  195.     f_string (R_PLANTAB,    C_SETTM-1,    "Set Time");
  196.     f_string (R_PLANTAB,    C_SETAZ,    "Set Az");
  197.     f_string (R_PLANTAB,    C_TUP-1,    "Hours Up");
  198. }
  199.  
  200. static
  201. alt3_labels()
  202. {
  203.     f_string (R_ALTM, C_ALTMV, "  Separations");
  204.  
  205.     alt_plnames();
  206.     f_string (R_PLANTAB,    C_SUN,        " Sun");
  207.     f_string (R_PLANTAB,    C_MOON,        "Moon");
  208.     f_string (R_PLANTAB,    C_MERCURY,    "Merc");
  209.     f_string (R_PLANTAB,    C_VENUS,    "Venus");
  210.     f_string (R_PLANTAB,    C_MARS,        "Mars");
  211.     f_string (R_PLANTAB,    C_JUPITER,    " Jup");
  212.     f_string (R_PLANTAB,    C_SATURN,    " Sat");
  213.     f_string (R_PLANTAB,    C_URANUS,    "Uranus");
  214.     f_string (R_PLANTAB,    C_NEPTUNE,    " Nep");
  215.     f_string (R_PLANTAB,    C_PLUTO,    "Pluto");
  216.     f_string (R_PLANTAB,    C_OBJX,        "  X");
  217.     f_string (R_PLANTAB,    C_OBJY,        "  Y");
  218. }
  219.  
  220. /* print body info in first menu format */
  221. static void
  222. alt1_body (int p, int force, Now *np)
  223. {
  224.     Sky sky;
  225.     double as = plot_ison() || srch_ison() ? 0.0 : 60.0;
  226.     int row = bodyrow[p];
  227.  
  228.     if (body_cir (p, as, np, &sky) || force) {
  229.         f_ra (row, C_RA, sky.s_ra);
  230.         f_angle (row, C_DEC, sky.s_dec);
  231.         if (sky.s_hlong != NOHELIO) {
  232.         f_angle (row, C_HLONG, sky.s_hlong);
  233.         if (p != SUN)
  234.             f_angle (row, C_HLAT, sky.s_hlat);
  235.         }
  236.  
  237.         if (p == MOON) {
  238.         /* distance is on km, show in miles */
  239.         f_double (R_MOON, C_EDIST, "%6.0f", sky.s_edist/1.609344);
  240.         } else if (sky.s_edist > 0.0) {
  241.         /* show distance in au */
  242.         f_double (row, C_EDIST,(sky.s_edist>=10.0)?"%6.3f":"%6.4f",
  243.                                 sky.s_edist);
  244.         }
  245.         if (sky.s_sdist > 0.0)
  246.         f_double (row, C_SDIST, (sky.s_sdist>=9.99995)?"%6.3f":"%6.4f",
  247.                                 sky.s_sdist);
  248.         if (p != SUN)
  249.         f_double (row, C_ELONG, "%6.1f", sky.s_elong);
  250.         f_double (row, C_SIZE, sky.s_size >= 99.95 ?"%4.0f":"%4.1f",
  251.                                 sky.s_size);
  252.         f_double (row, C_MAG, sky.s_mag <= -9.95 ? "%4.0f" : "%4.1f",
  253.                                 sky.s_mag);
  254.         if (sky.s_sdist > 0.0) {
  255. #ifdef AMIGA
  256.         int col = C_PHASE;
  257. #else
  258.         /* some terminals scroll when write a char in low-right corner.
  259.          * TODO: is there a nicer way to handle this maybe?
  260.          */
  261.         int col = row == NR ? C_PHASE - 1 : C_PHASE;
  262.         /* would just do this if Turbo-C 2.0 "%?.0f" worked:
  263.          * f_double (row, col, "%3.0f", sky.s_phase);
  264.          */
  265. #endif
  266.         f_int (row, col, "%3d", sky.s_phase);
  267.         }
  268.     }
  269.  
  270.     f_angle (row, C_AZ, sky.s_az);
  271.     f_angle (row, C_ALT, sky.s_alt);
  272. }
  273.  
  274. /* print body info in the second menu format */
  275. static void
  276. alt2_body (int p, int force, Now *np)
  277. {
  278.     double ltr, lts, ltt, azr, azs, altt;
  279.     int row = bodyrow[p];
  280.     int status;
  281.     double tmp;
  282.     int today_tup = 0;
  283.  
  284.     /* always recalc OBJX and Y since we don't know it's the same object */
  285.     if (!riset_cir (p, np, p==OBJX || p==OBJY, alt2_stdhzn?STDHZN:ADPHZN,
  286.         <r, <s, <t, &azr, &azs, &altt, &status) && !force)
  287.         return;
  288.  
  289.     alt_nobody (p);
  290.  
  291.     if (status & RS_ERROR) {
  292.         /* can not find where body is! */
  293.         f_string (row, C_RISETM, "?Error?");
  294.         return;
  295.     }
  296.     if (status & RS_CIRCUMPOLAR) {
  297.         /* body is up all day */
  298.         f_string (row, C_RISETM, "Circumpolar");
  299.         if (status & RS_NOTRANS)
  300.         f_string (row, C_TRANSTM, "No transit");
  301.         else {
  302.         f_mtime (row, C_TRANSTM, ltt);
  303.         if (status & RS_2TRANS)
  304.             f_char (row, C_TRANSTM+5, '+');
  305.         f_angle (row, C_TRANSALT, altt);
  306.         }
  307.         f_string (row, C_TUP, "24:00"); /*f_mtime() changes to 0:00 */
  308.         return;
  309.     }
  310.     if (status & RS_NEVERUP) {
  311.         /* body never up at all today */
  312.         f_string (row, C_RISETM, "Never up");
  313.         f_mtime (row, C_TUP, 0.0);
  314.         return;
  315.     }
  316.  
  317.     if (status & RS_NORISE) {
  318.         /* object does not rise as such today */
  319.         f_string (row, C_RISETM, "Never rises");
  320.         ltr = 0.0; /* for TUP */
  321.         today_tup = 1;
  322.     } else {
  323.         f_mtime (row, C_RISETM, ltr);
  324.         if (status & RS_2RISES) {
  325.         /* object rises more than once today */
  326.         f_char (row, C_RISETM+5, '+');
  327.         }
  328.         f_angle (row, C_RISEAZ, azr);
  329.     }
  330.  
  331.     if (status & RS_NOTRANS)
  332.         f_string (row, C_TRANSTM, "No transit");
  333.     else {
  334.         f_mtime (row, C_TRANSTM, ltt);
  335.         if (status & RS_2TRANS)
  336.         f_char (row, C_TRANSTM+5, '+');
  337.         f_angle (row, C_TRANSALT, altt);
  338.     }
  339.  
  340.     if (status & RS_NOSET) {
  341.         /* object does not set as such today */
  342.         f_string (row, C_SETTM, "Never sets");
  343.         lts = 24.0;    /* for TUP */
  344.         today_tup = 1;
  345.     } else {
  346.         f_mtime (row, C_SETTM, lts);
  347.         if (status & RS_2SETS)
  348.         f_char (row, C_SETTM+5, '+');
  349.         f_angle (row, C_SETAZ, azs);
  350.     }
  351.  
  352.     tmp = lts - ltr;
  353.     if (tmp < 0)
  354.         tmp = 24.0 + tmp;
  355.     f_mtime (row, C_TUP, tmp);
  356.     if (today_tup)
  357.         f_char (row, C_TUP+5, '+');
  358. }
  359.  
  360. /* print body info in third menu format. this may be either the geocentric
  361.  *   or topocentric angular separation between object p and each of the others.
  362.  *   the latter, of course, includes effects of refraction and so can change
  363.  *   quite rapidly near the time of each planets rise or set.
  364.  * for now, we don't save old values so we always redo everything and ignore
  365.  *  the "force" argument. this isn't that bad since body_cir() has memory and
  366.  *   will avoid most computations as we hit them again in the lower triangle.
  367.  * we are limited to only 5 columns per object. to make it fit, we display
  368.  *   degrees:minutes if less than 100 degrees, otherwise just whole degrees.
  369.  */
  370. /*ARGSUSED*/
  371. static void
  372. alt3_body (int p, int force, Now *np)
  373. {
  374.     int row = bodyrow[p];
  375.     Sky skyp, skyq;
  376.     double spy, cpy, px, *qx, *qy;
  377.     int wantx = obj_ison(OBJX);
  378.     int wanty = obj_ison(OBJY);
  379.     double as = plot_ison() || srch_ison() ? 0.0 : 60.0;
  380.     int q;
  381.  
  382.     (void) body_cir (p, as, np, &skyp);
  383.     if (alt3_geoc) {
  384.         /* use ra for "x", dec for "y". */
  385.         spy = sin (skyp.s_dec);
  386.         cpy = cos (skyp.s_dec);
  387.         px = skyp.s_ra;
  388.         qx = &skyq.s_ra;
  389.         qy = &skyq.s_dec;
  390.     } else {
  391.         /* use azimuth for "x", altitude for "y". */
  392.         spy = sin (skyp.s_alt);
  393.         cpy = cos (skyp.s_alt);
  394.         px = skyp.s_az;
  395.         qx = &skyq.s_az;
  396.         qy = &skyq.s_alt;
  397.     }
  398.     for (q = nxtbody(-1); q != -1; q = nxtbody(q))
  399.         if (q != p && (q != OBJX || wantx) && (q != OBJY || wanty)) {
  400.         double sep, dsep;
  401.         (void) body_cir (q, as, np, &skyq);
  402.         sep = acos(spy*sin(*qy) + cpy*cos(*qy)*cos(px-*qx));
  403.         dsep = raddeg(sep);
  404.         if (dsep >= (100.0 - 1.0/60.0/2.0))
  405.             f_int (row, bodycol[q], "%5d:", dsep);
  406.         else
  407.             f_angle (row, bodycol[q], sep);
  408.         }
  409. }
  410.